home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / userio.c < prev    next >
Text File  |  1993-08-23  |  8KB  |  351 lines
  1. /* userio.c */
  2. /************************************************************************
  3.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  4.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  5.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  6.  *                                                                      *
  7.  * All rights reserved.  No part of this program may be reproduced,     *
  8.  * stored in a retrieval system, or transmitted, in any form or by any  *
  9.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  10.  * without the prior written permission of the copyright owner,         *
  11.  * NeuralWare, Inc.                                                     *
  12.  *                                                                      *
  13.  *                          PROPRIETARY NOTICE                          *
  14.  *                                                                      *
  15.  * This document is the property of NeuralWare, Inc. and contains       *
  16.  * trade-secrets and other proprietary information.  The information    *
  17.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  18.  * published, reproduced, copied, disclosed, used, or reverse           *
  19.  * engineered without the express written consent of a duly authorized  *
  20.  * representative of NeuralWare.                                        *
  21.  ************************************************************************
  22.  */
  23.  
  24. /*******************************************************************/
  25. /*                                                                 */
  26. /*    userio.c -   Sample User I/O program                         */
  27. /*                                                                 */
  28. /*    Author: John C. Fairman           August 31, 1990            */
  29. /*    Copyright 1990 by NeuralWare Inc.                            */
  30. /*                                                                 */
  31. /*    $Author   :  $                                               */
  32. /*    $Date     :  $                                               */
  33. /*    $Source   :  $                                               */
  34. /*    $Revision :  $                                               */
  35. /*    $Log      :  $                                               */
  36. /*                                                                 */
  37. /*******************************************************************/
  38.  
  39. #define UIO_SERVER             1
  40. #define SERVER_EMULATOR_FILE   1
  41. #define SKIP_COMPAT_DATA       1
  42. #include "userutl.h"
  43. #include "uio_strc.h"
  44. #include "uio_tran.h"
  45. #include "uio_reqs.pro"
  46. #include "uio_cmds.pro"
  47.  
  48. #ifdef MAC
  49. #include "macuio.redef"
  50. #endif
  51.  
  52. /*******************************************************************/
  53. /*                                                                 */
  54. /* Functions necessary for handling the User I/O package itself.   */
  55. /*                                                                 */
  56. /*******************************************************************/
  57.  
  58. /*ARGSUSED */
  59. /* FUNCTION */
  60. NINT UIO_Init(file)
  61. TEXT *file;
  62. {
  63.   NINT ret_val = UIO_OK;
  64.  
  65.  
  66.   /* USER TO PLACE CODE HERE */
  67.  
  68.   return(ret_val);
  69. }
  70.  
  71.  
  72. /* */
  73. /*ARGSUSED*/
  74. /* FUNCTION */
  75. NINT UIO_Term(process)
  76. NINT process;
  77. {
  78.   PutStr( "bye bye\n" );
  79.  
  80.   return(UIO_OK);
  81. }
  82.  
  83.  
  84. /* FUNCTION */
  85. NINT UIO_Attention()
  86. {
  87.   NINT ret_val = UIO_OK;
  88.  
  89.  
  90.   /* USER TO PLACE CODE HERE */
  91.  
  92.   return(ret_val);
  93. }
  94.  
  95.  
  96. /*******************************************************************/
  97. /*                                                                 */
  98. /*  Functions necessary for handling a learning session.           */
  99. /*                                                                 */
  100. /*******************************************************************/
  101.  
  102. /* FUNCTION */
  103. NINT UIO_Learn_Start()
  104. {
  105.   NINT ret_val = UIO_OK;
  106.  
  107.  
  108.   /* USER TO PLACE CODE HERE */
  109.  
  110.   return(ret_val);
  111. }
  112.  
  113.  
  114. /* */
  115. /*ARGSUSED*/
  116. /* FUNCTION */
  117. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  118. NINT  LayN;
  119. NINT  nPEs;
  120. SREAL *Datap;
  121. {
  122.         char *sp;       /* string pointer */
  123.         int   wx;       /* work index */
  124.  
  125.   NINT ret_val = UIO_OK;
  126.  
  127.   PutStr( "Enter Two Digits (ex: 00) as input or 'E' End XOR: " );
  128.   sp = GetStr();
  129.  
  130.   /* Terminate learning if user types 'E' */
  131.   if ( *sp == 'e' || *sp == 'E' ) {
  132.     ret_val = UIO_ERROR;
  133.     goto rtrn;
  134.   }
  135.  
  136.   for( wx=0; wx < nPEs; wx++, sp++ ) {
  137.       while( *sp != '\0' && *sp <= ' ' )
  138.     sp++;       /* skip white space */
  139.       if ( *sp == '\0' ) break;   /* no more data */
  140.       Datap[wx] = (*sp=='0'? 0.0:1.0);  /* set data */
  141.   }
  142.  
  143.   while( wx < nPEs ) Datap[wx++] = 0.0; /* no data for these */
  144.  
  145.       rtrn:
  146.   return(ret_val);
  147. }
  148.  
  149. /*ARGSUSED*/
  150. /* FUNCTION */
  151. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  152. NINT  LayN;
  153. NINT  nPEs;
  154. SREAL *Datap;
  155. {
  156.         char *sp;       /* string pointer */
  157.         int   wx;       /* work index */
  158.   NINT ret_val = UIO_OK;
  159.  
  160.   PutStr( "Enter desired Output as a single digit: " );
  161.   sp = GetStr();
  162.  
  163.   wx = 0;
  164.   while( *sp != '\0' && *sp <= ' ' )
  165.       sp++;       /* skip white space */
  166.   Datap[wx++] = (*sp=='0'? 0.0:1.0);  /* set data */
  167.  
  168.   while( wx < nPEs ) Datap[wx++] = 0.0; /* no data for these */
  169.  
  170.   return(ret_val);
  171. }
  172.  
  173.  
  174. /* */
  175. /*ARGSUSED*/
  176. /* FUNCTION */
  177. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  178. NINT  LayN;
  179. NINT  nPEs;
  180. SREAL *Datap;
  181. {
  182.   NINT ret_val = UIO_OK;
  183.  
  184.  
  185.   /* USER TO PLACE CODE HERE */
  186.  
  187.   return(ret_val);
  188. }
  189.  
  190.  
  191. /* FUNCTION */
  192. NINT UIO_Learn_End()
  193. {
  194.   NINT ret_val = UIO_OK;
  195.  
  196.  
  197.   /* USER TO PLACE CODE HERE */
  198.  
  199.   return(ret_val);
  200. }
  201.  
  202.  
  203. /* */
  204. /*******************************************************************/
  205. /*                                                                 */
  206. /*  Functions necessary for handling a recall or testing session.  */
  207. /*                                                                 */
  208. /*******************************************************************/
  209.  
  210. /* FUNCTION */
  211. NINT UIO_Recall_Start()
  212. {
  213.   NINT ret_val = UIO_OK;
  214.  
  215.  
  216.   /* USER TO PLACE CODE HERE */
  217.  
  218.   return(ret_val);
  219. }
  220.  
  221.  
  222. /* FUNCTION */
  223. NINT UIO_Read(LayN, nPEs, Datap)
  224. NINT  LayN;
  225. NINT  nPEs;
  226. SREAL *Datap;
  227. {
  228.   return( UIO_Learn_Input(LayN, nPEs, Datap ) );
  229. }
  230.  
  231.  
  232. /* */
  233. /*ARGSUSED*/
  234. /* FUNCTION */
  235. NINT UIO_Write(LayN, nPEs, Datap)
  236. NINT  LayN;
  237. NINT  nPEs;
  238. SREAL *Datap;
  239. {
  240.         char  buf[100];       /* work buffer */
  241.  
  242.   sprintf( buf, "Result is: %.3f\n", Datap[0] );
  243.   PutStr( buf );
  244.   return( UIO_UPDATE);      /* update display */
  245. }
  246.  
  247.  
  248. /*ARGSUSED*/
  249. /* FUNCTION */
  250. NINT UIO_Write_Step(LayN, nPEs, Datap)
  251. NINT  LayN;
  252. NINT  nPEs;
  253. SREAL *Datap;
  254. {
  255.   NINT ret_val = UIO_OK;
  256.  
  257.  
  258.   /* USER TO PLACE CODE HERE */
  259.  
  260.   return(ret_val);
  261. }
  262.  
  263.  
  264. /* */
  265. /* FUNCTION */
  266. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  267. NINT  LayN;
  268. NINT  nPEs;
  269. SREAL *Datap;
  270. {
  271.         return(UIO_Learn_Output(LayN, nPEs, Datap));
  272. }
  273.  
  274. /* FUNCTION */
  275. NINT UIO_Recall_End()
  276. {
  277.   NINT ret_val = UIO_OK;
  278.  
  279.  
  280.   /* USER TO PLACE CODE HERE */
  281.  
  282.   return(ret_val);
  283. }
  284.  
  285.  
  286. /* */
  287. /*******************************************************************/
  288. /*                                                                 */
  289. /*  Other miscellaneous functions.                                  */
  290. /*                                                                 */
  291. /*******************************************************************/
  292.  
  293. /*ARGSUSED*/
  294. /* FUNCTION */
  295. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  296. NINT  Instrument_id;
  297. NINT  nDataElems;
  298. SREAL *DataElemp;
  299. {
  300.   NINT ret_val = UIO_OK;
  301.  
  302.  
  303.   /* USER TO PLACE CODE HERE */
  304.  
  305.   return(ret_val);
  306. }
  307.  
  308.  
  309. /* FUNCTION */
  310. NINT UIO_ObjFunc(eoeflag, DataElemp)
  311. NINT  eoeflag;
  312. SREAL *DataElemp;
  313. {
  314.   NINT ret_val = UIO_OK;
  315.  
  316.   /* USER TO PLACE CODE HERE */
  317.  
  318.   return(ret_val);
  319. }
  320.  
  321. /* FUNCTION */
  322. NINT UIO_Rewind()
  323. {
  324.   NINT ret_val = UIO_OK;
  325.  
  326.  
  327.   /* USER TO PLACE CODE HERE */
  328.  
  329.   return(ret_val);
  330. }
  331.  
  332.  
  333. /* */
  334. /*ARGSUSED*/
  335. /* FUNCTION */
  336. NINT UIO_Explain(LayN, nPEs, Datap)
  337. NINT  LayN;
  338. NINT  nPEs;
  339. SREAL *Datap;
  340. {
  341.   NINT ret_val = UIO_OK;
  342.  
  343.  
  344.   /* USER TO PLACE CODE HERE */
  345.  
  346.   return(ret_val);
  347. }
  348.  
  349.  
  350.  
  351.